{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# प्रशिक्षण: खासगी डीप लर्निंगचे मूलभूत साधने\n",
    "\n",
    "\n",
    "\n",
    "गोपनीयता जतन, विकेंद्रित गहन शिक्षणासाठी PySyft च्या प्रास्ताविक प्रशिक्षणात आपले स्वागत आहे. नोटबुकची ही मालिका एका अधिकाराखाली केंद्रीकृत न करता गुप्त / खाजगी डेटा / मॉडेल्सवर सखोल शिक्षण घेण्यासाठी आवश्यक असलेली नवीन साधने आणि तंत्रे जाणून घेण्यासाठी आपल्याला चरण-दर-चरण मार्गदर्शक आहेत.\n",
    "\n",
    "**व्याप्ती:** लक्षात ठेवा आम्ही केवळ डेटाचे विकेंद्रीकरण(decentralized) / \n",
    "एन्क्रिप्ट(encrypt) कसे करावे याबद्दल बोलत आहोत असे नाही तर डेटा संग्रहित आणि क्वेरी(query) केलेल्या डेटाबेस-समवेत डेटाच्या भोवतालच्या परिसंस्थेचे विकेंद्रीकरण करण्यात आणि डेटामधून माहिती काढण्यासाठी वापरल्या जाणार्‍या न्यूरल मॉडेल्सच्या(neural network)संधरबात PySyft चा कसा उपयोग करता येईल यावर आम्ही चर्चा करीत आहोत. जसजसे PySyft मध्ये नवीन extension तयार होत जातील, तसतसे या नोटबुकमध्ये नवीन कार्यक्षमतेचे स्पष्टीकरण देण्यासाठी नवीन ट्यूटोरियल पाठवले जाईल.\n",
    "\n",
    "\n",
    "लेखक:\n",
    "- Andrew Trask - Twitter: [@iamtrask](https://twitter.com/iamtrask)\n",
    "\n",
    "अनुवादक:\n",
    "- Krunal Kshirsagar  - Twitter : [@krunal_wrote](https://twitter.com/krunal_wrote) - Github: [@Noob-can-Compile](https://github.com/Noob-can-Compile)\n",
    "\n",
    "\n",
    "\n",
    "## सुरवातीचा आराखडा:\n",
    "\n",
    "- भाग 1: खाजगी डीप लर्निंगचे मूळ साधने. \n",
    "\n",
    "\n",
    "##  हे ट्यूटोरियल का घ्यायचे?\n",
    "\n",
    "**1) स्पर्धात्मक कारकीर्दीचा फायदा** - मागील 20 वर्षांपासून, डिजिटल क्रांतीमुळे डेटा जास्त प्रमाणात उपलब्ध झाला आहे कारण एनालॉग प्रक्रिया डिजिटल झाल्या आहेत. तथापि, [GDPR](https://eugdpr.org/) नवीन नियमनानुसार उद्योजकांवर कसे वापरावे - आणि महत्त्वाचे म्हणजे ते कसे विश्लेषित करतात - वैयक्तिक माहिती यावर कमी स्वातंत्र्य मिळवण्याचा दबाव असतो. **Bottom Line:** डेटा शास्त्रज्ञांना जुन्या(old school) साधनांसह जास्तीत जास्त डेटामध्ये प्रवेश मिळणार नाही, परंतु खाजगी डीप लर्निंगची साधने शिकून आपण या वक्रतेपेक्षा पुढे असू शकता आणि आपल्या कारकीर्दीत स्पर्धात्मक फायदा घेऊ शकता.\n",
    "\n",
    "\n",
    "**2) उद्योजकीय संधी** - समाजात डिप्प लर्निंग सोडवू शकणार्‍या अनेक समस्या आहेत, परंतु बर्‍याच महत्त्वाच्या गोष्टींचा शोध लावला गेला नाही कारण त्यासाठी लोकांबद्दल आश्चर्यकारकपणे संवेदनशील माहिती मिळवणे आवश्यक आहे (तुम्ही डीप लर्निंगचा वापर मानसिक किंवा नातेसंबंध समस्या सोढवण्यासाठी लोकांना मदत करुशकतात!). अशाप्रकारे, खाजगी डीप लर्निंग शिकणे आपल्यासाठी नवीन स्टार्टअप संधींचे संपूर्ण विस्तार उघडते जे या टूलसेटशिवाय इतरांना पूर्वी उपलब्ध नव्हते.\n",
    "\n",
    "\n",
    "**3) सोशल गुड** - डीप लर्निंगचा उपयोग खर्‍या जगातील विविध समस्या सोडविण्यासाठी केला जाऊ शकतो, परंतु वैयक्तिक माहितीवर डीप लर्निंग म्हणजे लोकांसंबंधी, लोकांसाठी डीप लर्निंग. आपल्या मालकीच्या नसलेल्या डेटावर डीप लर्निंग कसे करावे हे शिकणे हे करिअर किंवा उद्योजकीय संधीपेक्षा अधिक प्रतिनिधित्व करते, लोकांच्या जीवनातील काही सर्वात वैयक्तिक आणि महत्त्वपूर्ण समस्या सोडविण्यास मदत करण्याची संधी - आणि तेही प्रमाणात करणे.\n",
    "\n",
    "\n",
    "## मला अतिरिक्त क्रेडिट कसे मिळेल?\n",
    "\n",
    "- Pysyft ला Github वर Star करा! - [https://github.com/OpenMined/PySyft](https://github.com/OpenMined/PySyft)\n",
    "- ह्या नोटबुकची माहिती देणारा किंवा शिकवणारा एक यूट्यूब व्हिडिओ बनवा!\n",
    "\n",
    "\n",
    "\n",
    "... ठीक आहे ... चला सुरुवात करूया!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# भाग -1: पूर्वनिर्धारितता\n",
    "\n",
    "- PyTorch जाणून घ्या - नसल्यास http://fast.ai कोर्स घ्या आणि परत या..\n",
    "- PySyft फ्रेमवर्क पेपर https://arxiv.org/pdf/1811.04017.pdf वाचा! हे आपल्याला PySyft कसे तयार केले आहे यावर एक सखोल पार्श्वभूमी देईल जे गोष्टींना अधिक अर्थ प्राप्त करण्यास मदत करेल."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# भाग 0: सेटअप\n",
    "सुरू करण्यासाठी, आपल्याला खात्री करुन घ्यावी लागेल की आपल्याकडे योग्य गोष्टी स्थापित केल्या आहेत. असे करण्यासाठी, PySyft च्या readme जा आणि सेटअपच्या सूचनांचे अनुसरण करा. बहुतेक लोकांसाठी TLDR आहे.\n",
    "\n",
    "- Install Python 3.6 or higher\n",
    "- Install PyTorch 1.4\n",
    "- pip install syft[udacity]\n",
    "\n",
    "\n",
    "जर यापैकी कोणताही भाग आपल्यासाठी कार्य करत नसेल (किंवा कोणत्याही चाचण्या अयशस्वी झाल्या असतील तर) - प्रथम इन्स्टॉलेशन मदतीसाठी [README](https://github.com/OpenMined/PySyft.git) तपासा आणि नंतर एक GitHub Issue उघडा किंवा आमच्या स्लॅकमध्ये #beginner चॅनेलला पिंग करा! [slack.openmined.org](http://slack.openmined.org/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# गोष्टी कार्यरत आहेत की नाही हे पाहण्यासाठी हा सेल चालवा\n",
    "import sys\n",
    "\n",
    "import torch\n",
    "from torch.nn import Parameter\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import syft as sy\n",
    "hook = sy.TorchHook(torch)\n",
    "\n",
    "torch.tensor([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "जर या सेलची अंमलबजावणी झाली तर आपण शर्यतींसाठी निघाला आहात! चला हे करूया!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# भाग 1: खासगी (Private), विकेंद्रीकरण (Decentralized ) डेटा विज्ञान चे मूलभूत साधने\n",
    "\n",
    "तर - आपण याच्यात पहिला प्रश्न विचारू शकता तो असा आहे - आपल्याकडे प्रवेश नसलेल्या डेटावर,आपण आपले मॉडेल कसे प्रशिक्षीत करू सकतो ?\n",
    "\n",
    "पण, उत्तर आश्चर्यकारकपणे सोपे आहे. जर आपण PyTorch मध्ये काम करण्याची सवय लावत असाल, तर आपण torch.Tensor सारख्या वस्तूंच्या मदतीने काम करण्याची सवय लावली आहे!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 2,  4,  6,  8, 10])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([1,2,3,4,5])\n",
    "y = x + x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "अर्थात हे सुपर फॅन्सी (आणि शक्तिशाली!) टेन्सर वापरणे महत्वाचे आहे, परंतु आपल्याकडे आपल्या स्थानिक मशीनवर डेटा असणे आवश्यक आहे. येथून आपला प्रवास सुरू होतो.\n",
    "\n",
    "# विभाग 1.1 - बॉबच्या मशीनवर Tensor पाठवणे.\n",
    "\n",
    "सामान्यत: आपण डेटा ठेवणाऱ्या मशीनवर डेटा सायन्स / डीप लर्निंगचे प्रदर्शन करत असे, आता आपल्याला दुसर्‍या मशीनवर या प्रकारचे गणित करायचे आहे. विशेषतः, आपण यापुढे डेटा आपल्या स्थानिक मशीनवर आहे असे समजू शकत नाही.\n",
    "\n",
    "अशाप्रकारे, Torch Tensor  वापरण्याऐवजी, आपण आता पॉईंटर्ससह टेन्सरवर काम करणार आहोत. मला काय म्हणायचे आहे ते मी तुम्हाला दाखवतो. प्रथम, \"सोंग\"(pretend) मशीन बनवू जे \"सोंग\"(pretend) व्यक्तीच्या मालकीचे आहे - आपण त्याला बॉब(Bob) म्हणू."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob = sy.VirtualWorker(hook, id=\"bob\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "समजा बॉबचे मशीन दुसर्‍या ग्रहावर आहे - कदाचित मंगळावर! पण, याक्षणी मशीन रिक्त आहे. चला काही डेटा तयार करू जेणेकरुन आपण ते बॉबला पाठवू आणि पॉईंटर्सबद्दल (Pointers) शिकू!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([1,2,3,4,5])\n",
    "y = torch.tensor([1,1,1,1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आणि आता - चला आपले टेन्सर बॉबला(Bob) पाठवू !!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_ptr = x.send(bob)\n",
    "y_ptr = y.send(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:8030612864 -> bob:14597461368]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "BOOM! आता बॉबकडे(Bob) दोन Tensor आहेत! माझ्यावर विश्वास नाही? हे स्वत: पहा!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{14597461368: tensor([1, 2, 3, 4, 5]), 86863779266: tensor([1, 1, 1, 1, 1])}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob._objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = x_ptr + x_ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:25749208299 -> bob:51980816025]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{14597461368: tensor([1, 2, 3, 4, 5]),\n",
       " 86863779266: tensor([1, 1, 1, 1, 1]),\n",
       " 51980816025: tensor([ 2,  4,  6,  8, 10])}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob._objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आता थोड लक्षात घ्या. जेव्हा आपण `x.send(bob)` म्हटले तेव्हा ते नवीन ऑब्जेक्ट परत केले ज्याला आपण `x_ptr` म्हटले. एका टेन्सरसाठी हा आमचा पहिला पॉईंटर आहे. Pointers to tensors प्रत्यक्षात स्वत: चा डेटा ठेवत नाहीत. त्याऐवजी, ते फक्त मशीनवर संग्रहित एका Tensor(डेटासह) बद्दल मेटाडेटा असतात. या टेन्सरचा हेतू आम्हाला अंतर्ज्ञानी एपीआय प्रदान करणे आहे जे या टेन्सरद्वारे इतर मशीनला कार्ये मोजण्यास सांगते. चला Pointer असलेल्या मेटाडेटावर एक नजर टाकू."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:8030612864 -> bob:14597461368]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "तो मेटाडेटा पहा!\n",
    "\n",
    "\n",
    "Pointers शी संबंधित दोन मुख्य वैषिष्टे आहेत:\n",
    "\n",
    "- `x_ptr.location : bob`, स्थान, (Pointer) ज्या ठिकाणी निर्देशित करीत आहे त्या स्थानाचा संदर्भ. \n",
    "- `x_ptr.id_at_location : <random integer>`, ज्या ठिकाणी Tensor संग्रहित असेल तो आयडी.\n",
    "\n",
    "ह्या स्वरूपात मुद्रित आहेत `<id_at_location>@<location>`\n",
    "\n",
    "इतरही सामान्य गुणधर्म आहेत:\n",
    "- `x_ptr.id : <random integer>`, आपल्या पॉईंटर Tensor चा आयडी, यादृच्छिकपणे(Randomly Allocated) त्याचा वाटप करण्यात आला. \n",
    "- `x_ptr.owner : \"me\"`, पॉईंटर (Pointer) टेन्सरचा मालक असलेला वर्कर, येथे तो स्थानिक वर्कर आहे, ज्याचे नाव \"me\" आहे. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<VirtualWorker id:bob #tensors:3>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr.location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<VirtualWorker id:bob #tensors:3>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob == x_ptr.location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14597461368"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr.id_at_location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<VirtualWorker id:me #tensors:0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr.owner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आपण आश्चर्यचकित होऊ शकता की (Pointer) चा मालक असलेला स्थानिक कर्मचारीसुद्धा एक VirtualWorker आहे, जरी आम्ही तो तयार केलेला नाही. मजेदार तथ्य, जसे आपल्याकडे (Bob)साठी VirtualWorker ऑब्जेक्ट होता, तसे आपल्याकडे देखील (डीफॉल्टनुसार) नेहमीच असतो. जेव्हा आम्ही hook = sy.TorchHook() म्हणतो तेव्हा हा कार्यकर्ता आपोआप तयार होतो आणि म्हणूनच आपल्याला सहसा ते तयार करण्याची आवश्यकता नसते."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<VirtualWorker id:me #tensors:0>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "me = sy.local_worker\n",
    "me"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "me == x_ptr.owner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आणि शेवटी, ज्याप्रमाणे आपण Tensor वर .send() कॉल करू शकतो, तसे Tensor परत मिळवण्यासाठी आपण पॉईंटर (Pointer) वर .get () कॉल करू शकतो !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:8030612864 -> bob:14597461368]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_ptr.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:35059460605 -> bob:86863779266]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_ptr.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob._objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आणि जसे आपण पाहू शकता ... बॉब(Bob)कडे यापुढे टेन्सर नाही !!! ते परत आपल्या मशीनकडे गेले आहेत!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# विभाग 1.2 - Using Tensor Pointers\n",
    "\n",
    "तर, बॉब(Bob)कडून टेन्सर(Tensor) पाठविणे आणि प्राप्त करणे चांगले आहे, परंतु हे डिप्प लर्निंगच नाही! आपल्याला रिमोट टेन्सर(Remote Tensor)वर Tensor _operations_ करण्यास सक्षम व्हायचे आहे. सुदैवाने, Tensor पॉईंटर्स(Pointers) हे बरेच सोपे करतात! आपण सामान्य Tensor सारखेच पॉईंटर्स(Pointers) वापरू शकता!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([1,2,3,4,5]).send(bob)\n",
    "y = torch.tensor([1,1,1,1,1]).send(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:64292397072 -> bob:52057427318]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "आणि पहा (And voilà!) \n",
    "\n",
    "पडद्यामागे काहीतरी खूप शक्तिशाली घडले. स्थानिकरित्या x आणि y चे संगणन करण्याऐवजी, आज्ञा क्रमबद्ध केली गेली आणि बॉब(Bob)ला पाठविली गेली, त्याने गणना केली, एक टेन्सर(Tensor) z तयार केला, आणि नंतर पॉईंटरला z पाठवून परत आपल्याकडे परत केले!\n",
    "\n",
    "आपण पॉईंटरवर(Pointer) .get () कॉल केल्यास आपल्याला  आपल्या मशीनवर पुन्हा निकाल मिळेल!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Torch कार्य (Functions)\n",
    "\n",
    "हा एपीआय(API) Torch चे सर्व ऑपरेशन्समध्ये विस्तारित केला गेला आहे !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:61648270672 -> bob:41935419076]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:91696528814 -> bob:72852698267]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:52401050415 -> bob:48387803230]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = torch.add(x,y)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### व्हेरिएबल्स (Variables) (backpropagation सह!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([1,2,3,4,5.], requires_grad=True).send(bob)\n",
    "y = torch.tensor([1,1,1,1,1.], requires_grad=True).send(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (x + y).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Wrapper)>[PointerTensor | me:97949899326 -> bob:26737740170]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = x.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 2., 3., 4., 5.], requires_grad=True)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "म्हणूनच आपण पाहू शकता, एपीआय(API) खरोखरच लवचिक आहे आणि आपण साधारणपणे रिमोट डेटावरील(Remote Data) Torch मध्ये करता असे कोणतेही ऑपरेशन करण्यास सक्षम आहे. हे आमच्या अधिक प्रगत गोपनीयता संरक्षित प्रोटोकॉल(advanced privacy preserving protocols) जसे की फेडरेटेड लर्निंग(Federated Learning), सिक्युर मल्टी-पार्टी कंप्यूटेशन(Secure Multi-Party Computation) आणि डिफरेंशियल प्रायव्हसी(Differential Privacy) यासाठी आधारभूत कार्य करते!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# अभिनंदन !!! - समुदायात सामील होण्याची वेळ आली!\n",
    "\n",
    "\n",
    "हे नोटबुक ट्यूटोरियल पूर्ण केल्याबद्दल अभिनंदन! आपण याचा आनंद घेत असल्यास आणि एआय(AI) आणि एआय सप्लाय चेन (डेटा) च्या विकेंद्रित(Decentralized) मालकीच्या गोपनीयतेच्या संरक्षणाच्या दिशेने चळवळीत सामील होऊ इच्छित असाल तर आपण हे खालील प्रकारे करू शकता!\n",
    "\n",
    "### Pysyft ला Github वर Star करा!\n",
    "\n",
    "आमच्या समुदायाला मदत करण्याचा सर्वात सोपा मार्ग म्हणजे फक्त गिटहब(GitHub) रेपो(Repo) तारांकित(Star) करणे! हे आम्ही तयार करीत असलेल्या छान साधनांविषयी जागरूकता वाढविण्यास मदत करते.\n",
    "\n",
    "- [Star PySyft](https://github.com/OpenMined/PySyft)\n",
    "\n",
    "### आमच्या Slack मध्ये सामील व्हा!\n",
    "\n",
    "\n",
    "नवीनतम प्रगतीवर अद्ययावत राहण्याचा उत्तम मार्ग म्हणजे आमच्या समुदायामध्ये सामील होणे! आपण [http://slack.openmined.org](http://slack.openmined.org) येथे फॉर्म भरुन तसे करू शकता.\n",
    "\n",
    "### एका कोड प्रोजेक्टमध्ये सामील व्हा!\n",
    "\n",
    "आमच्या समुदायामध्ये योगदानाचा उत्तम मार्ग म्हणजे कोड योगदानकर्ता बनणे! कोणत्याही वेळी आपण (PySyft GitHub Issues Page) वर  जाऊ शकता आणि \"Project\" साठी फिल्टर करू शकता. हे आपण कोणत्या प्रकल्पांमध्ये सामील होऊ शकता याबद्दल विहंगावलोकन देणारी सर्व उच्च स्तरीय तिकिटे दर्शवेल! आपण एखाद्या प्रकल्पात सामील होऊ इच्छित नसल्यास, परंतु आपण थोडं कोडिंग करू इच्छित असाल तर आपण \"good first issues\" म्हणून चिन्हांकित गिटहब(GitHub) अंक शोधून आणखी \"one off\" मिनी-प्रकल्प(mini project) शोधू शकता.\n",
    "\n",
    "- [PySyft Projects](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3AProject)\n",
    "- [Good First Issue Tickets](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n",
    "\n",
    "### दान करा\n",
    "\n",
    "आपल्याकडे आमच्या कोडेबेसमध्ये योगदान देण्यास वेळ नसल्यास, परंतु तरीही आपल्याला समर्थन द्यावयाचे असल्यास आपण आमच्या मुक्त संग्रहात बॅकर देखील होऊ शकता. सर्व देणगी आमच्या वेब होस्टिंग आणि हॅकॅथॉन आणि मेटअप्स सारख्या इतर सामुदायिक खर्चाकडे जातात!\n",
    "\n",
    "[OpenMined's Open Collective Page](https://opencollective.com/openmined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}